A Fast Distributed Stateless Algorithm for α\alpha-Fair Packing Problems

Over the past two decades, fair resource allocation problems have received considerable attention in a variety of application areas. However, little progress has been made in the design of distributed algorithms with convergence guarantees for general and commonly used $\alpha$-fair allocations. In this paper, we study weighted $\alpha$-fair packing problems, that is, the problems of maximizing the objective functions (i) $\sum_j w_j x_j^{1-\alpha}/(1-\alpha)$ when $\alpha > 0$, $\alpha \neq 1$ and (ii) $\sum_j w_j \ln x_j$ when $\alpha = 1$, over linear constraints $Ax \leq b$, $x\geq 0$, where $w_j$ are positive weights and $A$ and $b$ are non-negative. We consider the distributed computation model that was used for packing linear programs and network utility maximization problems. Under this model, we provide a distributed algorithm for general $\alpha$ that converges to an $\varepsilon-$approximate solution in time (number of distributed iterations) that has an inverse polynomial dependence on the approximation parameter $\varepsilon$ and poly-logarithmic dependence on the problem size. This is the first distributed algorithm for weighted $\alpha-$fair packing with poly-logarithmic convergence in the input size. The algorithm uses simple local update rules and is stateless (namely, it allows asynchronous updates, is self-stabilizing, and allows incremental and local adjustments). We also obtain a number of structural results that characterize $\alpha-$fair allocations as the value of $\alpha$ is varied. These results deepen our understanding of fairness guarantees in $\alpha-$fair packing allocations, and also provide insight into the behavior of $\alpha-$fair allocations in the asymptotic cases $\alpha\rightarrow 0$, $\alpha \rightarrow 1$, and $\alpha \rightarrow \infty$.Comment: Added structural results for asymptotic cases of \alpha-fairness (\alpha approaching 0, 1, or infinity), improved presentation, and revised throughou

Cluster Before You Hallucinate: Approximating Node-Capacitated Network Design and Energy Efficient Routing

We consider circuit routing with an objective of minimizing energy, in a network of routers that are speed scalable and that may be shutdown when idle. We consider both multicast routing and unicast routing. It is known that this energy minimization problem can be reduced to a capacitated flow network design problem, where vertices have a common capacity but arbitrary costs, and the goal is to choose a minimum cost collection of vertices whose induced subgraph will support the specified flow requirements. For the multicast (single-sink) capacitated design problem we give a polynomial-time algorithm that is O(log^3n)-approximate with O(log^4 n) congestion. This translates back to a O(log ^(4{\alpha}+3) n)-approximation for the multicast energy-minimization routing problem, where {\alpha} is the polynomial exponent in the dynamic power used by a router. For the unicast (multicommodity) capacitated design problem we give a polynomial-time algorithm that is O(log^5 n)-approximate with O(log^12 n) congestion, which translates back to a O(log^(12{\alpha}+5) n)-approximation for the unicast energy-minimization routing problem.Comment: 22 pages (full version of STOC 2014 paper

Coresets Meet EDCS: Algorithms for Matching and Vertex Cover on Massive Graphs

As massive graphs become more prevalent, there is a rapidly growing need for scalable algorithms that solve classical graph problems, such as maximum matching and minimum vertex cover, on large datasets. For massive inputs, several different computational models have been introduced, including the streaming model, the distributed communication model, and the massively parallel computation (MPC) model that is a common abstraction of MapReduce-style computation. In each model, algorithms are analyzed in terms of resources such as space used or rounds of communication needed, in addition to the more traditional approximation ratio. In this paper, we give a single unified approach that yields better approximation algorithms for matching and vertex cover in all these models. The highlights include: * The first one pass, significantly-better-than-2-approximation for matching in random arrival streams that uses subquadratic space, namely a $(1.5+\epsilon)$-approximation streaming algorithm that uses $O(n^{1.5})$ space for constant $\epsilon > 0$. * The first 2-round, better-than-2-approximation for matching in the MPC model that uses subquadratic space per machine, namely a $(1.5+\epsilon)$-approximation algorithm with $O(\sqrt{mn} + n)$ memory per machine for constant $\epsilon > 0$. By building on our unified approach, we further develop parallel algorithms in the MPC model that give a $(1 + \epsilon)$-approximation to matching and an $O(1)$-approximation to vertex cover in only $O(\log\log{n})$ MPC rounds and $O(n/poly\log{(n)})$ memory per machine. These results settle multiple open questions posed in the recent paper of Czumaj~et.al. [STOC 2018]

Rounding Algorithms for a Geometric Embedding of Minimum Multiway Cut

The multiway-cut problem is, given a weighted graph and k >= 2 terminal nodes, to find a minimum-weight set of edges whose removal separates all the terminals. The problem is NP-hard, and even NP-hard to approximate within 1+delta for some small delta > 0. Calinescu, Karloff, and Rabani (1998) gave an algorithm with performance guarantee 3/2-1/k, based on a geometric relaxation of the problem. In this paper, we give improved randomized rounding schemes for their relaxation, yielding a 12/11-approximation algorithm for k=3 and a 1.3438-approximation algorithm in general. Our approach hinges on the observation that the problem of designing a randomized rounding scheme for a geometric relaxation is itself a linear programming problem. The paper explores computational solutions to this problem, and gives a proof that for a general class of geometric relaxations, there are always randomized rounding schemes that match the integrality gap.Comment: Conference version in ACM Symposium on Theory of Computing (1999). To appear in Mathematics of Operations Researc

How to Schedule When You Have to Buy Your Energy

Abstract. We consider a situation where jobs arrive over time at a data center, consisting of identical speed-scalable processors. For each job, the scheduler knows how much income is lost as a function of how long the job is delayed. The scheduler also knows the fixed cost of a unit of energy. The online scheduler determines which jobs to run on which processors, and at what speed to run the processors. The scheduler's objective is to maximize profit, which is the income obtained from jobs minus the energy costs. We give a (1+ )-speed O(1)-competitive algorithm, and show that resource augmentation is necessary to achieve O(1)-competitiveness